package com.weave.tree;

import com.weave.printer.BinaryTreeInfo;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Description 二叉树
 * @Author weave
 * @Date 2023/10/18 9:46
 */
@SuppressWarnings("unchecked")
public class BinaryTree<E> implements BinaryTreeInfo {
    protected int size;
    protected Node<E> root;

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 先序遍历
     * @param visitor visitor
     */
    public void preOrder(Visitor<E> visitor){
        if(visitor == null){
            return;
        }
        preOrder(root,visitor);
    }
    private void preOrder(Node<E> node,Visitor<E> visitor){
        if(node == null || visitor.stop){
            return;
        }

        visitor.stop = visitor.visit(node.element);
        preOrder(node.left,visitor);
        preOrder(node.right,visitor);
    }

    /**
     * 中序遍历
     * @param visitor visitor
     */
    public void inOrder(Visitor<E> visitor){
        if(visitor == null){
            return;
        }
        inOrder(root,visitor);
    }
    private void inOrder(Node<E> node,Visitor<E> visitor){
        if(node == null || visitor.stop){
            return;
        }

        inOrder(node.left,visitor);
        if(visitor.stop){
            return;
        }
        visitor.stop = visitor.visit(node.element);
        inOrder(node.right,visitor);
    }

    /**
     * 后序遍历
     * @param visitor visitor
     */
    public void postOrder(Visitor<E> visitor){
        if(visitor == null){
            return;
        }
        postOrder(root,visitor);
    }
    private void postOrder(Node<E> node,Visitor<E> visitor){
        if(node == null || visitor.stop){
            return;
        }

        postOrder(node.left,visitor);
        postOrder(node.right,visitor);
        if(visitor.stop){
            return;
        }
        visitor.stop = visitor.visit(node.element);
    }

    /**
     * 层序遍历
     * @param visitor
     */
    public void levelOrder(Visitor<E> visitor){
        if (root == null || visitor == null) {
            return;
        }

        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            Node<E> node = queue.poll();
            if(visitor.visit(node.element)){
                return;
            }
            if(node.left != null){
                queue.offer(node.left);
            }
            if(node.right != null){
                queue.offer(node.right);
            }
        }
    }

    /**
     * 判断是否是完全二叉树
     * 1. 最后一层必须是叶子结点；2. 最后一层要么只是左结点，要么是左右两结点
     * @return
     */
    public boolean isComplete(){
        if (root == null) {
            return false;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        boolean leaf = false;
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()) {
                return false;
            }

            if (node.left != null) {
                queue.offer(node.left);
            } else if (node.right != null) {
                return false;
            }

            if (node.right != null) {
                queue.offer(node.right);
            } else {
                /*
                   到这里,就要求后面都是叶子结点，不然就不满足完全二叉树的定义
                 */
                leaf = true;
            }
        }

        return true;
    }

    public int height(){
        if(root == null){
            return 0;
        }

        int height = 0;
        int levelSize = 1;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            Node<E> node = queue.poll();
            levelSize--;

            if(node.left != null){
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if(levelSize == 0){
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }
    public int height2(){
        return height(root);
    }
    private int height(Node<E> node){
        if(node == null){
            return 0;
        }
        return 1+Math.max(height(node.left),height(node.right));
    }

    /**
     * 前驱结点：中序遍历时的前一个结点
     * @param node ndoe
     * @return Node<E>
     */
    protected Node<E> predecessor(Node<E> node){
        if(node == null){
            return null;
        }
        // 1. 前驱结点在左子树中，比如root结点的前驱结点
        Node<E> pre = node.left;
        if(pre != null){
            while(pre.right != null){
                pre = pre.right;
            }
            return pre;
        }

        // 2. 叶子结点，从父结点、祖父结点中寻找
        while(node.parent != null && node == node.parent.left){
            node = node.parent;
        }
        // 来到这里有以下两种情况:
        // node.parent == null	无前驱, 说明是根结点
        // node.parent...right == node 找到【某结点为父节点或祖父节点的右子树中】
        // 那么父节点就是某节点的前驱节点
        return node.parent;
    }

    /**
     * 后继结点：中序遍历时的后一个结点
     * 后继节点与前驱节点正好相反
     * @param node node
     * @return Node<E>
     */
    protected Node<E> successor(Node<E> node){
        if (node == null) {
            return null;
        }

        // 后继节点在右子树中（node.right.left.left...）
        if (node.right != null) {
            Node<E> p = node.right;
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }

        // 来到这里说明没有右节点, 则从父节点、祖父节点中寻找后继节点
        // 当父节点不为空, 且某节点为父节点的右子节点
        // 则顺着父节点找, 直到找到【某结点在父节点或祖父节点的左子树中】时
        while (node.parent != null && node.parent.right == node) {
            node = node.parent;
        }

        // 来到这里有以下两种情况:
        // node.parent == null 无前驱，说明是根结点
        // node.parent.left == node 找到【某结点在父节点或祖父节点的左子树中】
        // 那么父节点就是某节点的后继节点
        return node.parent;


    }

    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>)node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>)node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> myNode = (Node<E>)node;
        String parentString = "null";
        if(myNode.parent != null){
            parentString = myNode.parent.element.toString();
        }
        return myNode.element + "_p(" + parentString + ")";
    }

    protected static class Node<E>{
        E element;
        Node<E> left;
        Node<E> right;
        Node<E> parent;

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        public boolean isLeaf() {
            return left == null && right == null;
        }

        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }

    /**
     * 访问者设计模式
     * 在这个设计模式中，我们创建了一个`Visitor`抽象类，它定义了一个`visit(E element)`方法。这个方法在每次访问树的节点时都会被调用.
     * 这种设计模式允许我们在不改变数据结构的情况下，添加新的操作到数据结构上。
     * 在这个例子中，数据结构是一个二叉树，而新的操作是前序遍历。这种设计模式非常适合于数据结构相对稳定，而操作经常变化的场景。
     */
    public static abstract class Visitor<E> {
        boolean stop;

        /**
         *
         * @param element element
         * @return 返回true即表示停止遍历
         */
        abstract boolean visit(E element);
    }
}
